import utils from "@/lib/utils";
import storage from "@/lib/storage/storage";
//字典列表 key,val 缓存

let DictionaryMap: any = null;

/**
 * 字典
 */
export interface Dict {
    /**
     * Id
     */
    id: string;
    /**
     * 所属部门机构ID
     */
    bid: string;
    /**
     * 名称
     */
    title: string;
    /**
     * 唯一标识
     */
    only_key: string;
    /**
     * 类型 1字典  2系统设置
     */
    type: number;
    /**
     * 是否多数据 1单个数据 2多个数据【数组】
     */
    multiple: number;
    /**
     * 数据类型 1字符串  2整数  3小数
     */
    int_type: number;
    /**
     * 单个数据
     */
    value: DictVal;
    /**
     * 多个数据(数组)
     */
    values: DictVal[];
    /**
     * 是否启用 ，1启用 2禁用
     */
    enable: number;
    /**
     * 排序
     */
    sort: number;
    /**
     * 备注
     */
    desc: string;
}

/**
 * 数据
 */
export interface DictVal {
    /**
     * 数据标签
     */
    label: string;
    /**
     * 字符数据
     */
    str_value: string;
    /**
     * 整数数据
     */
    int_value: number;
    /**
     * 小数数据
     */
    float_value: number;
    /**
     * 数据表现文本颜色
     */
    txt_color: string;
    /**
     * 数据表现背景颜色
     */
    background_color: string;
}

export function defaultDict(): Dict {
    return {
        id: "",
        bid: "",
        title: "",
        only_key: "",
        type: 1,
        multiple: 2,
        int_type: 1,
        value: {
            label: "",
            str_value: "",
            int_value: 0,
            float_value: 0,
            txt_color: "#000000",
            background_color: "#FFFFFF"
        },
        values: [],
        enable: 1,
        sort: 1,
        desc: "",
    };
}

class Dictionary {
    private dictMap: Map<string, Dict> = new Map();
    private sysMap: Map<string, Dict> = new Map();

    /**
     * 根据数据类型获取对应的数据字段名称
     * @param type 数据类型 1字符串  2整数  3小数
     */
    public getFieldName(type: number = 0): string {
        let fieldName: string = "";
        switch (type) {
            case 1:
                fieldName = "str_value";
                break;
            case 2:
                fieldName = "int_value";
                break;
            case 3:
                fieldName = "float_value";
                break;
        }
        return fieldName;
    }

    /**
     * 根据数据类型获取对应的数据值
     * @param type 数据类型 1字符串  2整数  3小数
     * @param val 数据值对象
     */
    public getDataTypeValue(type: number = 0, val: DictVal): any {
        let resVal: any = "";
        switch (type) {
            case 1:
                resVal = val.str_value;
                break;
            case 2:
                resVal = val.int_value;
                break;
            case 3:
                resVal = val.float_value;
                break;
        }
        return resVal;
    }

    /**
     * 获取字典
     * @param key 字典唯一标识
     */
    public get(key: string) {
        const mapKey = `${key}-1`;
        const temVal = this.dictMap.get(mapKey);
        if (!utils.empty(temVal)) {
            return temVal;
        } else {
            if (utils.empty(DictionaryMap)) {
                DictionaryMap = storage.dictionary.Get();
            }
            return DictionaryMap[key];
        }
    }

    /**
     * 获取系统设置字典
     * @param key 系统设置字典唯一标识
     */
    public getSys(key: string) {
        const mapKey = `${key}-1`;
        const temVal = this.dictMap.get(mapKey);
        if (!utils.empty(temVal)) {
            return temVal;
        } else {
            if (utils.empty(DictionaryMap)) {
                DictionaryMap = storage.dictionary.Get();
            }
            return DictionaryMap[key];
        }
    }

    /**
     * 获取 单个数据的字典值
     * @param data 字典对象
     */
    public getOneValue(data: Dict): any {
        let temVal: any = "";
        if (data.multiple === 1) {
            switch (data.int_type) {
                case 1:
                    temVal = data.value.str_value;
                    break;
                case 2:
                    temVal = data.value.int_value;
                    break;
                case 3:
                    temVal = data.value.float_value;
                    break;
            }
        }
        return temVal;
    }

    /**
     * 通过值 获取 单个数据的字典标签
     * @param data 字典对象
     */
    public getOneLabel(data: Dict, val: any = ""): any {
        let temVal: any = val;
        if (data.multiple === 1) {
            switch (data.int_type) {
                case 1:
                    if (data.value.str_value === val) {
                        temVal = data.value.label;
                    }
                    break;
                case 2:
                    if (data.value.int_value === val) {
                        temVal = data.value.label;
                    }
                    break;
                case 3:
                    if (data.value.float_value === val) {
                        temVal = data.value.label;
                    }
                    break;
            }
        }
        return temVal;
    }

    /**
     * 通过数据值 获取标签
     * @param data 字典对象
     * @param val 数据值
     */
    public getLbel(data: Dict, val: any = ""): string {
        let resVal: string = val;
        if (utils.empty(val)) {
            return resVal;
        }
        if (data.multiple === 1) {
            switch (data.int_type) {
                case 1:
                    if (data.value.str_value === val) {
                        resVal = data.value.label;
                    }
                    break;
                case 2:
                    if (data.value.int_value === val) {
                        resVal = data.value.label;
                    }
                    break;
                case 3:
                    if (data.value.float_value === val) {
                        resVal = data.value.label;
                    }
                    break;
            }
        } else if (data.multiple === 2) {
            switch (data.int_type) {
                case 1:
                    for (const item of data.values) {
                        if (item.str_value == val) {
                            resVal = item.label;
                            break;
                        }
                    }
                    break;
                case 2:
                    for (const item of data.values) {
                        if (item.int_value == val) {
                            resVal = item.label;
                            break;
                        }
                    }
                    break;
                case 3:
                    for (const item of data.values) {
                        if (item.float_value == val) {
                            resVal = item.label;
                            break;
                        }
                    }
                    break;
            }
        }
        return resVal;
    }

    /**
     * 通过数据标签 获取数据值
     * @param data 字典对象
     * @param val 数据值
     */
    public getValue(data: Dict, val: any = ""): any {
        let resVal: any = "";
        if (utils.empty(val)) {
            return resVal;
        }
        if (data.multiple === 1) {
            switch (data.int_type) {
                case 1:
                    resVal = data.value.str_value;
                    break;
                case 2:
                    resVal = data.value.int_value;
                    break;
                case 3:
                    resVal = data.value.float_value;
                    break;
            }
        } else if (data.multiple === 2) {
            for (const item of data.values) {
                if (item.label === val) {
                    switch (data.int_type) {
                        case 1:
                            resVal = item.str_value;
                            break;
                        case 2:
                            resVal = item.int_value;
                            break;
                        case 3:
                            resVal = item.float_value;
                            break;
                    }
                    break;
                }
            }
        }
        return resVal;
    }

    /**
     * 通过数据值 获取文本展示颜色
     * @param data 字典对象
     * @param val 数据值
     */
    public getTxtColor(data: Dict, val: any = ""): string {
        let resVal: string = "#000000";
        if (utils.empty(val)) {
            return resVal;
        }
        if (data.multiple === 1) {
            resVal = data.value.txt_color;
        } else if (data.multiple === 2) {
            for (const item of data.values) {
                if (data.int_type === 1 && item.str_value === val) {
                    resVal = item.txt_color;
                    break;
                } else if (data.int_type === 2 && item.int_value === val) {
                    resVal = item.txt_color;
                    break;
                } else if (data.int_type === 3 && item.float_value === val) {
                    resVal = item.txt_color;
                    break;
                }
            }
        }
        return resVal;
    }

    /**
     * 通过数据值 获取背景展示颜色
     * @param data 字典对象
     * @param val 数据值
     */
    public getBackgroundColor(data: Dict, val: any = ""): string {
        let resVal: string = "#FFFFFF";
        if (utils.empty(val)) {
            return resVal;
        }
        if (data.multiple === 1) {
            resVal = data.value.background_color;
        } else if (data.multiple === 2) {
            for (const item of data.values) {
                if (data.int_type === 1 && item.str_value === val) {
                    resVal = item.background_color;
                    break;
                } else if (data.int_type === 2 && item.int_value === val) {
                    resVal = item.background_color;
                    break;
                } else if (data.int_type === 3 && item.float_value === val) {
                    resVal = item.background_color;
                    break;
                }
            }
        }
        return resVal;
    }
}

/**
 * 程序字典
 */
export default new Dictionary();
